/**
 * 增强型路由助手
 * 
 * 功能特点：
 * 1. 支持多种路径格式：
 *    - 相对路径 (../../xxx/yyy)
 *    - 绝对路径 (/xxx/yyy)
 *    - 命名路由 (home, my-profile 等)
 * 
 * 2. 智能路径解析：
 *    - 自动解析URL中的查询参数
 *    - 将相对路径基于当前页面正确解析
 *    - 支持路由名称映射到实际页面路径
 * 
 * 3. 增强的错误处理：
 *    - 详细的调试日志
 *    - 路由失败时优雅降级到微信原生导航
 *    - 统一的错误提示机制
 * 
 * 4. 兼容原有项目代码结构：
 *    - 与page_helper.js无缝集成
 *    - 保持API的一致性
 * 
 * 使用方式：
 * 1. 直接调用：routerHelper.navigateTo('home')
 * 2. 带参数：routerHelper.navigateTo('detail?id=123')
 * 3. 相对路径：routerHelper.navigateTo('../../detail/index')
 */

// 导入相关模块
const router = require('../miniprogram_npm/libs_migration/router/index');
const routerConfig = require('../miniprogram_npm/libs_migration/router/router-config');
const { debug, logError, showError, tryCatch } = require('../miniprogram_npm/libs_migration/router/error-handler');

// 默认开启调试模式
const enableDebug = true;

/**
 * 记录调试日志
 */
function logDebug(...args) {
  if (enableDebug) {
    console.log('[Router]', ...args);
  }
}

/**
 * 检查是否为直接路径
 */
function isDirectPath(path) {
  return typeof path === 'string' && path.charAt(0) === '/';
}

/**
 * 检查是否为相对路径
 */
function isRelativePath(path) {
  return typeof path === 'string' && (path.startsWith('../') || path.startsWith('./'));
}

/**
 * 将参数对象转换为查询字符串
 */
function objectToQuery(obj) {
  if (!obj || typeof obj !== 'object' || Object.keys(obj).length === 0) {
    return '';
  }
  
  return Object.keys(obj)
    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}`)
    .join('&');
}

/**
 * 解析URL中的路径和参数
 */
function parseURL(url) {
  if (typeof url !== 'string') return { path: url, params: {} };
  
  const result = { path: url, params: {} };
  
  if (url.includes('?')) {
    const [path, queryStr] = url.split('?');
    result.path = path;
    
    // 解析参数
    const pairs = queryStr.split('&');
    for (let pair of pairs) {
      const [key, value] = pair.split('=');
      if (key && value) {
        result.params[decodeURIComponent(key)] = decodeURIComponent(value);
      }
    }
  }
  
  logDebug('解析URL结果:', result);
  return result;
}

/**
 * 将相对路径转换为绝对路径
 */
function resolveRelativePath(path) {
  if (!path) return '';
  
  // 获取当前页面栈
  const pages = getCurrentPages();
  if (!pages || pages.length === 0) {
    logDebug('当前页面栈为空，无法解析相对路径');
    return path;
  }
  
  const currentPage = pages[pages.length - 1];
  if (!currentPage || !currentPage.route) {
    logDebug('当前页面对象不存在或无路由信息，无法解析相对路径');
    return path;
  }
  
  const currentPath = currentPage.route;
  
  logDebug(`解析相对路径: ${path}, 当前页面: ${currentPath}`);
  
  // 分割当前路径
  const currentParts = currentPath.split('/');
  currentParts.pop(); // 移除最后的文件名部分
  
  // 处理 ./ 开头的相对路径
  if (path.startsWith('./')) {
    path = path.substring(2);
    return [...currentParts, path].join('/');
  }
  
  // 处理 ../ 开头的相对路径
  if (path.startsWith('../')) {
    const pathParts = path.split('/');
    let result = [...currentParts];
    
    for (const part of pathParts) {
      if (part === '..') {
        result.pop(); // 向上一级目录
      } else if (part !== '') {
        result.push(part); // 添加路径部分
      }
    }
    
    const resolvedPath = result.join('/');
    logDebug(`相对路径解析结果: ${resolvedPath}`);
    return resolvedPath;
  }
  
  return path;
}

/**
 * 在路由配置中查找路径对应的路由名称
 */
function findRouteNameByPath(path) {
  // 标准化路径，去掉开头的斜杠
  const normalizedPath = path.startsWith('/') ? path.substr(1) : path;
  
  // 在路由配置中查找匹配的路径
  for (const [name, config] of Object.entries(routerConfig.routeMap)) {
    if (config.path === normalizedPath) {
      logDebug(`找到路径对应的路由名: ${name}`);
      return name;
    }
  }
  
  return null;
}

/**
 * 导航到指定页面
 */
function navigateTo(nameOrPathWithQuery, params = {}, data = null) {
  try {
    // 记录详细日志
    logDebug('navigateTo 调用:');
    logDebug('- 原始参数:', { nameOrPathWithQuery, params, data });
    
    // 解析URL及参数
    const { path: nameOrPath, params: urlParams } = parseURL(nameOrPathWithQuery);
    
    // 合并URL中的参数和传入的参数
    const mergedParams = { ...urlParams, ...params };
    
    logDebug('- 解析后:', { nameOrPath, mergedParams });
    
    // 处理相对路径
    if (isRelativePath(nameOrPath)) {
      const resolvedPath = resolveRelativePath(nameOrPath);
      logDebug(`- 解析相对路径: ${nameOrPath} -> ${resolvedPath}`);
      
      // 尝试获取路由名称
      const routeName = findRouteNameByPath(resolvedPath);
      
      // 如果找到路由名称，使用命名路由方式
      if (routeName) {
        logDebug(`- 使用命名路由: ${routeName}`);
        try {
          router.push({
            name: routeName,
            query: mergedParams,
            data,
            fail: (err) => {
              logError(`路由跳转失败: ${err.errMsg || JSON.stringify(err)}`);
              // 降级使用直接路径
              const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
                '?' + objectToQuery(mergedParams) : ''}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.navigateTo({ url });
            }
          });
        } catch (err) {
          logError('路由调用异常', err);
          // 降级使用直接路径
          const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
            '?' + objectToQuery(mergedParams) : ''}`;
          logDebug(`- 异常降级: ${url}`);
          wx.navigateTo({ url });
        }
      }
      // 否则使用解析后的路径
      else {
        logDebug(`- 使用解析后的路径: ${resolvedPath}`);
        const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
          '?' + objectToQuery(mergedParams) : ''}`;
        logDebug(`- 最终URL: ${url}`);
        wx.navigateTo({ url });
      }
    }
    // 处理命名路由
    else if (!nameOrPath.includes('/')) {
      logDebug(`- 使用命名路由: ${nameOrPath}`);
      try {
        router.push({
          name: nameOrPath,
          query: mergedParams,
          data,
          fail: (err) => {
            logError(`路由跳转失败: ${err.errMsg || JSON.stringify(err)}`);
            
            // 尝试从路由配置中获取路径
            const route = routerConfig.routeMap[nameOrPath];
            if (route) {
              const url = `/${route.path}${Object.keys(mergedParams).length > 0 ? 
                '?' + objectToQuery(mergedParams) : ''}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.navigateTo({ url });
            } else {
              showError('页面不存在');
            }
          }
        });
      } catch (err) {
        logError('路由调用异常', err);
        
        // 尝试从路由配置中获取路径
        const route = routerConfig.routeMap[nameOrPath];
        if (route) {
          const url = `/${route.path}${Object.keys(mergedParams).length > 0 ? 
            '?' + objectToQuery(mergedParams) : ''}`;
          logDebug(`- 异常降级: ${url}`);
          wx.navigateTo({ url });
        } else {
          showError('页面不存在');
        }
      }
    }
    // 处理直接路径
    else {
      logDebug(`- 使用直接路径: ${nameOrPath}`);
      
      // 规范化路径，确保开头有斜杠
      const path = nameOrPath.startsWith('/') ? nameOrPath : `/${nameOrPath}`;
      const url = `${path}${Object.keys(mergedParams).length > 0 ? 
        '?' + objectToQuery(mergedParams) : ''}`;
      
      logDebug(`- 最终URL: ${url}`);
      wx.navigateTo({ 
        url,
        fail: (err) => {
          logError(`页面跳转失败: ${err.errMsg}`);
          showError('页面跳转失败');
        }
      });
    }
  } catch (error) {
    logError('路由导航异常', error);
    
    // 显示错误提示
    showError('页面跳转失败');
    
    // 尝试使用最基本的导航方式
    if (typeof nameOrPathWithQuery === 'string') {
      const isPath = nameOrPathWithQuery.includes('/');
      
      if (isPath) {
        const path = nameOrPathWithQuery.startsWith('/') ? 
          nameOrPathWithQuery : `/${nameOrPathWithQuery}`;
        
        logDebug(`- 异常情况使用直接路径: ${path}`);
        wx.navigateTo({ url: path });
      } else {
        // 是路由名称，从配置中查找
        const route = routerConfig.routeMap[nameOrPathWithQuery];
        if (route) {
          const url = `/${route.path}`;
          logDebug(`- 异常情况使用路由配置路径: ${url}`);
          wx.navigateTo({ url });
        }
      }
    }
  }
}

/**
 * 关闭当前页面，跳转到应用内的某个页面
 */
function redirectTo(nameOrPathWithQuery, params = {}, data = null) {
  try {
    // 记录详细日志
    logDebug('redirectTo 调用:');
    logDebug('- 原始参数:', { nameOrPathWithQuery, params, data });
    
    // 解析URL及参数
    const { path: nameOrPath, params: urlParams } = parseURL(nameOrPathWithQuery);
    
    // 合并URL中的参数和传入的参数
    const mergedParams = { ...urlParams, ...params };
    
    logDebug('- 解析后:', { nameOrPath, mergedParams });
    
    // 处理相对路径
    if (isRelativePath(nameOrPath)) {
      const resolvedPath = resolveRelativePath(nameOrPath);
      logDebug(`- 解析相对路径: ${nameOrPath} -> ${resolvedPath}`);
      
      // 尝试获取路由名称
      const routeName = findRouteNameByPath(resolvedPath);
      
      // 如果找到路由名称，使用命名路由方式
      if (routeName) {
        logDebug(`- 使用命名路由: ${routeName}`);
        try {
          router.replace({
            name: routeName,
            query: mergedParams,
            data,
            fail: (err) => {
              logError(`路由重定向失败: ${err.errMsg || JSON.stringify(err)}`);
              // 降级使用直接路径
              const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
                '?' + objectToQuery(mergedParams) : ''}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.redirectTo({ url });
            }
          });
        } catch (err) {
          logError('路由调用异常', err);
          // 降级使用直接路径
          const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
            '?' + objectToQuery(mergedParams) : ''}`;
          logDebug(`- 异常降级: ${url}`);
          wx.redirectTo({ url });
        }
      }
      // 否则使用解析后的路径
      else {
        logDebug(`- 使用解析后的路径: ${resolvedPath}`);
        const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
          '?' + objectToQuery(mergedParams) : ''}`;
        logDebug(`- 最终URL: ${url}`);
        wx.redirectTo({ url });
      }
    }
    // 处理命名路由
    else if (!nameOrPath.includes('/')) {
      logDebug(`- 使用命名路由: ${nameOrPath}`);
      try {
        router.replace({
          name: nameOrPath,
          query: mergedParams,
          data,
          fail: (err) => {
            logError(`路由重定向失败: ${err.errMsg || JSON.stringify(err)}`);
            
            // 尝试从路由配置中获取路径
            const route = routerConfig.routeMap[nameOrPath];
            if (route) {
              const url = `/${route.path}${Object.keys(mergedParams).length > 0 ? 
                '?' + objectToQuery(mergedParams) : ''}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.redirectTo({ url });
            } else {
              showError('页面不存在');
            }
          }
        });
      } catch (err) {
        logError('路由调用异常', err);
        
        // 尝试从路由配置中获取路径
        const route = routerConfig.routeMap[nameOrPath];
        if (route) {
          const url = `/${route.path}${Object.keys(mergedParams).length > 0 ? 
            '?' + objectToQuery(mergedParams) : ''}`;
          logDebug(`- 异常降级: ${url}`);
          wx.redirectTo({ url });
        } else {
          showError('页面不存在');
        }
      }
    }
    // 处理直接路径
    else {
      logDebug(`- 使用直接路径: ${nameOrPath}`);
      
      // 规范化路径，确保开头有斜杠
      const path = nameOrPath.startsWith('/') ? nameOrPath : `/${nameOrPath}`;
      const url = `${path}${Object.keys(mergedParams).length > 0 ? 
        '?' + objectToQuery(mergedParams) : ''}`;
      
      logDebug(`- 最终URL: ${url}`);
      wx.redirectTo({ 
        url,
        fail: (err) => {
          logError(`页面重定向失败: ${err.errMsg}`);
          showError('页面重定向失败');
        }
      });
    }
  } catch (error) {
    logError('路由重定向异常', error);
    showError('页面重定向失败');
  }
}

/**
 * 关闭所有页面，打开到应用内的某个页面
 */
function reLaunch(nameOrPathWithQuery, params = {}, data = null) {
  try {
    // 记录详细日志
    logDebug('reLaunch 调用:');
    logDebug('- 原始参数:', { nameOrPathWithQuery, params, data });
    
    // 解析URL及参数
    const { path: nameOrPath, params: urlParams } = parseURL(nameOrPathWithQuery);
    
    // 合并URL中的参数和传入的参数
    const mergedParams = { ...urlParams, ...params };
    
    logDebug('- 解析后:', { nameOrPath, mergedParams });
    
    // 处理相对路径
    if (isRelativePath(nameOrPath)) {
      const resolvedPath = resolveRelativePath(nameOrPath);
      logDebug(`- 解析相对路径: ${nameOrPath} -> ${resolvedPath}`);
      
      // 尝试获取路由名称
      const routeName = findRouteNameByPath(resolvedPath);
      
      // 如果找到路由名称，使用命名路由方式
      if (routeName) {
        logDebug(`- 使用命名路由: ${routeName}`);
        try {
          router.reLaunch({
            name: routeName,
            query: mergedParams,
            data,
            fail: (err) => {
              logError(`路由重启失败: ${err.errMsg || JSON.stringify(err)}`);
              // 降级使用直接路径
              const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
                '?' + objectToQuery(mergedParams) : ''}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.reLaunch({ url });
            }
          });
        } catch (err) {
          logError('路由调用异常', err);
          // 降级使用直接路径
          const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
            '?' + objectToQuery(mergedParams) : ''}`;
          logDebug(`- 异常降级: ${url}`);
          wx.reLaunch({ url });
        }
      }
      // 否则使用解析后的路径
      else {
        logDebug(`- 使用解析后的路径: ${resolvedPath}`);
        const url = `/${resolvedPath}${Object.keys(mergedParams).length > 0 ? 
          '?' + objectToQuery(mergedParams) : ''}`;
        logDebug(`- 最终URL: ${url}`);
        wx.reLaunch({ url });
      }
    }
    // 处理命名路由
    else if (!nameOrPath.includes('/')) {
      logDebug(`- 使用命名路由: ${nameOrPath}`);
      try {
        router.reLaunch({
          name: nameOrPath,
          query: mergedParams,
          data,
          fail: (err) => {
            logError(`路由重启失败: ${err.errMsg || JSON.stringify(err)}`);
            
            // 尝试从路由配置中获取路径
            const route = routerConfig.routeMap[nameOrPath];
            if (route) {
              const url = `/${route.path}${Object.keys(mergedParams).length > 0 ? 
                '?' + objectToQuery(mergedParams) : ''}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.reLaunch({ url });
            } else {
              showError('页面不存在');
            }
          }
        });
      } catch (err) {
        logError('路由调用异常', err);
        
        // 尝试从路由配置中获取路径
        const route = routerConfig.routeMap[nameOrPath];
        if (route) {
          const url = `/${route.path}${Object.keys(mergedParams).length > 0 ? 
            '?' + objectToQuery(mergedParams) : ''}`;
          logDebug(`- 异常降级: ${url}`);
          wx.reLaunch({ url });
        } else {
          showError('页面不存在');
        }
      }
    }
    // 处理直接路径
    else {
      logDebug(`- 使用直接路径: ${nameOrPath}`);
      
      // 规范化路径，确保开头有斜杠
      const path = nameOrPath.startsWith('/') ? nameOrPath : `/${nameOrPath}`;
      const url = `${path}${Object.keys(mergedParams).length > 0 ? 
        '?' + objectToQuery(mergedParams) : ''}`;
      
      logDebug(`- 最终URL: ${url}`);
      wx.reLaunch({ 
        url,
        fail: (err) => {
          logError(`页面重启失败: ${err.errMsg}`);
          showError('页面重启失败');
        }
      });
    }
  } catch (error) {
    logError('路由重启异常', error);
    showError('页面重启失败');
  }
}

/**
 * 跳转到 tabBar 页面
 */
function switchTab(nameOrPathWithQuery) {
  try {
    // 记录详细日志
    logDebug('switchTab 调用:');
    logDebug('- 原始参数:', { nameOrPathWithQuery });
    
    // 解析URL及参数（注意：tabBar页面不支持参数传递，但我们仍然解析URL以获取正确的path）
    const { path: nameOrPath } = parseURL(nameOrPathWithQuery);
    
    logDebug('- 解析后:', { nameOrPath });
    
    // 处理相对路径
    if (isRelativePath(nameOrPath)) {
      const resolvedPath = resolveRelativePath(nameOrPath);
      logDebug(`- 解析相对路径: ${nameOrPath} -> ${resolvedPath}`);
      
      // 尝试获取路由名称
      const routeName = findRouteNameByPath(resolvedPath);
      
      // 如果找到路由名称，使用命名路由方式
      if (routeName) {
        logDebug(`- 使用命名路由: ${routeName}`);
        try {
          router.switchTab({
            name: routeName,
            fail: (err) => {
              logError(`切换标签页失败: ${err.errMsg || JSON.stringify(err)}`);
              // 降级使用直接路径
              const url = `/${resolvedPath}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.switchTab({ url });
            }
          });
        } catch (err) {
          logError('路由调用异常', err);
          // 降级使用直接路径
          const url = `/${resolvedPath}`;
          logDebug(`- 异常降级: ${url}`);
          wx.switchTab({ url });
        }
      }
      // 否则使用解析后的路径
      else {
        logDebug(`- 使用解析后的路径: ${resolvedPath}`);
        const url = `/${resolvedPath}`;
        logDebug(`- 最终URL: ${url}`);
        wx.switchTab({ url });
      }
    }
    // 处理命名路由
    else if (!nameOrPath.includes('/')) {
      logDebug(`- 使用命名路由: ${nameOrPath}`);
      try {
        router.switchTab({
          name: nameOrPath,
          fail: (err) => {
            logError(`切换标签页失败: ${err.errMsg || JSON.stringify(err)}`);
            
            // 尝试从路由配置中获取路径
            const route = routerConfig.routeMap[nameOrPath];
            if (route) {
              const url = `/${route.path}`;
              logDebug(`- 降级使用路径: ${url}`);
              wx.switchTab({ url });
            } else {
              showError('页面不存在');
            }
          }
        });
      } catch (err) {
        logError('路由调用异常', err);
        
        // 尝试从路由配置中获取路径
        const route = routerConfig.routeMap[nameOrPath];
        if (route) {
          const url = `/${route.path}`;
          logDebug(`- 异常降级: ${url}`);
          wx.switchTab({ url });
        } else {
          showError('页面不存在');
        }
      }
    }
    // 处理直接路径
    else {
      logDebug(`- 使用直接路径: ${nameOrPath}`);
      
      // 规范化路径，确保开头有斜杠
      const path = nameOrPath.startsWith('/') ? nameOrPath : `/${nameOrPath}`;
      
      logDebug(`- 最终URL: ${path}`);
      wx.switchTab({ 
        url: path,
        fail: (err) => {
          logError(`切换标签页失败: ${err.errMsg}`);
          showError('切换标签页失败');
        }
      });
    }
  } catch (error) {
    logError('切换标签页异常', error);
    showError('切换标签页失败');
  }
}

/**
 * 返回上一页面
 */
function navigateBack(delta = 1) {
  try {
    wx.navigateBack({
      delta,
      fail: (err) => {
        logError(`返回失败: ${err.errMsg}`);
        // 如果返回失败，尝试返回到首页
        wx.reLaunch({ url: '/projects/oa/pages/default/index/default_index' });
      }
    });
  } catch (error) {
    logError('返回异常', error);
    // 如果异常，尝试返回到首页
    wx.reLaunch({ url: '/projects/oa/pages/default/index/default_index' });
  }
}

/**
 * 获取当前路由信息
 */
function getCurrentRoute() {
  const pages = getCurrentPages();
  if (!pages || pages.length === 0) {
    logDebug('当前页面栈为空，无法获取当前路由');
    return null;
  }
  
  const current = pages[pages.length - 1];
  if (!current || !current.route) {
    logDebug('当前页面对象不存在或无路由信息');
    return null;
  }
  
  return {
    path: current.route,
    options: current.options || {}
  };
}

/**
 * 获取页面数据
 */
function getPageData(options) {
  try {
    return router.extractData(options);
  } catch (error) {
    logError('获取页面数据异常', error);
    return null;
  }
}

// 导出函数
module.exports = {
  navigateTo,
  redirectTo,
  navigateBack,
  reLaunch,
  switchTab,
  getCurrentRoute,
  getPageData,
  objectToQuery,
  
  // 导出工具函数，供测试和调试使用
  parseURL,
  isRelativePath,
  isDirectPath,
  resolveRelativePath,
  findRouteNameByPath
}; 